package com.liveneo.adapter.outinterface.util;

import java.io.UnsupportedEncodingException;
import java.text.DateFormat;
import javax.servlet.ServletInputStream;
import org.apache.commons.codec.binary.Base64;
import com.alibaba.fastjson.TypeReference;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.liveneo.adapter.base.support.LogUtils;
import com.liveneo.common.utils.Base64Util;
import com.liveneo.common.utils.ByteUtil;
import com.liveneo.common.utils.JsonUtil;
import com.liveneo.common.utils.Request;

/**
 * Json处理工具类
 * 
 * @author liveneo
 *
 */
public class JsonUtils {
    /**
     * 对象转换为Json字符串
     * @param obj
     * @return
     */
    public static String toJson(Object obj) {
        Gson gson = new Gson();
        return gson.toJson(obj);
    }

    /**
     * 通过Json字符串转换为指定对象
     * @param jsonData
     * @param type
     * @return
     */
    public static <T> T fromJson(String jsonData, Class<T> type) {
        GsonBuilder builder = new GsonBuilder();
        builder.registerTypeAdapter(java.util.Date.class, new UtilDateDeserializer()).setDateFormat(DateFormat.LONG);
        Gson gson = builder.create();
        return gson.fromJson(jsonData, type);
    }

    /**
     * 通过Json字符串转换为指定对象
     * @param jsonData
     * @param type
     * @return
     */
    public static <T> T fromJsonToDate(String jsonData, Class<T> type) {
        GsonBuilder builder = new GsonBuilder();
        builder.setDateFormat("yyyy-MM-dd HH:mm:ss");
        Gson gson = builder.create();
        return gson.fromJson(jsonData, type);
    }

    /**
     * 对象转换为base64加密字符串
     * 
     * @param enc 使用编码
     * @return 对象的json的base64加密串
     * @throws UnsupportedEncodingException 
     */
    public static String toJsonWithBase64(Object obj, String enc) {
        // 对象转换成Json字符串
        String jsonStr = JsonUtils.toJson(obj);
        String jsonStrWithBase64 = null;
        try {
            // base64加密
            jsonStrWithBase64 = Base64.encodeBase64String(jsonStr.getBytes(enc));
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
        return jsonStrWithBase64;
    }

    /**
     * base64加密字符串转换为对象
     * 
     * @param enc 使用编码
     * @return 对象的json的base64加密串
     * @throws UnsupportedEncodingException 
     */
    public static <T> T fromJsonWithBase64(String base64JsonData, Class<T> type, String enc) {
        // 对象转换成Json字符串
        String jsonStrWithBase64 = null;
        try {
            // base64加密
            jsonStrWithBase64 = new String(Base64.decodeBase64(base64JsonData.getBytes(enc)), enc);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
        T obj = JsonUtils.fromJson(jsonStrWithBase64, type);
        return obj;
    }

    /**
     * 对象转换为base64加密字符串（使用UTF-8编码）
     * 
     * @return 对象的json的base64加密串
     * @throws UnsupportedEncodingException 
     */
    public static String toJsonWithBase64(Object obj) {
        return JsonUtils.toJsonWithBase64(obj, "UTF-8");
    }

    /**
     * base64加密字符串转换为对象（使用UTF-8编码）
     * 
     * @return 对象的json的base64加密串
     * @throws UnsupportedEncodingException 
     */
    public static <T> T fromJsonWithBase64(String base64JsonData, Class<T> type) {
        return JsonUtils.fromJsonWithBase64(base64JsonData, type, "UTF-8");
    }

    /**
      * @Title: fromJsonClaimBase64
      * @Description: 转换对象
      * @param @param is
      * @param @param type
      * @param @return 设定文件
      * @return Request<T> 返回类型
      * @throws
     */
    public static <T> Request<T> fromJsonClaimBase64(ServletInputStream is, Class<T> type) {
        try {
            // 获取参数
            String data = ByteUtil.xmlStringToInputStream(is, "utf-8");
            data = Base64Util.base64Decrypt(data, "utf-8");
            LogUtils.info("接收朗泰核心参数解析报文：" + data);
            Request<T> sr = JsonUtil.getObjectToBean(data, new TypeReference<Request<T>>() {
            });
            return sr;
        } catch (Exception e) {
            LogUtils.error("获取参数异常.", e);
        }
        return null;
    }

    /**
     * base64加密字符串转换为对象
     * 
     * @param enc 使用编码
     * @return 对象的json的base64加密串
     * @throws UnsupportedEncodingException 
     */
    public static String fromBase64WithJson(String base64JsonData) {
        // 对象转换成Json字符串
        String jsonStrWithBase64 = null;
        try {
            // base64解密
            jsonStrWithBase64 = new String(Base64.decodeBase64(base64JsonData.getBytes("utf-8")), "utf-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
        return jsonStrWithBase64;
    }
}
